package com.mm.cloth;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;

import android.os.Bundle;
import android.util.Log;
import android.view.MenuItem;
import android.widget.Toast;
import android.content.Intent;

import com.google.android.material.bottomnavigation.BottomNavigationView;
import com.mm.cloth.api.ApiClient;
import com.mm.cloth.fragment.ProfileFragment;
import com.mm.cloth.fragment.ToolsFragment;
import com.mm.cloth.fragment.WardrobeFragment;
import com.mm.cloth.fragment.MatchFragment;
import com.mm.cloth.utils.LoginCheckUtil;
import com.mm.cloth.utils.NetworkUtil;
import com.mm.cloth.utils.UpdateCheckUtil;

import java.util.List;
import com.mm.cloth.utils.LoginCheckUtil.LoginCallback;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    private BottomNavigationView bottomNavigationView;
    
    // 记录最后选中的导航项ID，用于在未登录时恢复到之前的选项
    private int lastSelectedItemId = R.id.nav_wardrobe;
    
    // 存储最近的登录回调
    private LoginCallback pendingLoginCallback = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        try {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);

            // 初始化底部导航栏
            bottomNavigationView = findViewById(R.id.bottom_navigation);

        } catch (Exception e) {
            Log.e(TAG, "MainActivity onCreate 异常", e);
            throw e;
        }
        
        try {
            // 使用更可靠的方式设置导航监听
            bottomNavigationView.setOnItemSelectedListener(this::onNavigationItemSelected);

            // 禁用重复选择同一个项目的默认效果
            bottomNavigationView.setOnItemReselectedListener(item -> {
                // 重新选择同一个导航项时，不做任何操作
                int itemId = item.getItemId();
                Log.d(TAG, "重新选择同一个导航项: ID=" + itemId + ", 标题=" + item.getTitle());
            });

            // 默认显示衣柜页面
            if (savedInstanceState == null) {
                lastSelectedItemId = R.id.nav_wardrobe;
                loadFragment(new WardrobeFragment());
            }

            // 检查应用更新
            checkForUpdates();

        } catch (Exception e) {
            Log.e(TAG, "MainActivity 初始化异常", e);
            throw e;
        }
    }

    /**
     * 处理底部导航栏的选择事件
     */
    public boolean onNavigationItemSelected(@NonNull MenuItem item) {
        int itemId = item.getItemId();
        String itemTitle = item.getTitle().toString();
        Log.d(TAG, "导航选择: ID=" + itemId + ", 标题=" + itemTitle);

        // 获取资源ID的名称
        String resourceName = getResources().getResourceName(itemId);
        Log.d(TAG, "资源名称: " + resourceName);
        
        // 检查当前Fragment
        Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.fragment_container);
        Log.d(TAG, "当前Fragment: " + (currentFragment != null ? currentFragment.getClass().getSimpleName() : "null"));

        // 判断是否需要登录的页面
        boolean needsLogin = false;
        Fragment targetFragment = null;
        
        switch (itemId) {
            case R.id.nav_wardrobe:
                Log.d(TAG, "切换到衣柜页面");
                targetFragment = new WardrobeFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_match:
                Log.d(TAG, "切换到搭配页面");
                targetFragment = new MatchFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_tools:
                Log.d(TAG, "切换到工具页面");
                targetFragment = new ToolsFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_profile:
                Log.d(TAG, "切换到我的页面");
                // 不再需要登录检查，直接创建并加载ProfileFragment
                
                // 如果当前已经在我的页面，不重复处理
                if (currentFragment instanceof ProfileFragment) {
                    Log.d(TAG, "当前已是ProfileFragment，无需重新创建");
                    lastSelectedItemId = itemId;
                    return true;
                }
                
                // 创建ProfileFragment实例
                try {
                    targetFragment = new ProfileFragment();
                    lastSelectedItemId = itemId;
                } catch (Exception e) {
                    Log.e(TAG, "创建ProfileFragment失败: " + e.getMessage(), e);
                    Toast.makeText(this, "加载个人页面失败", Toast.LENGTH_SHORT).show();
                    bottomNavigationView.setSelectedItemId(lastSelectedItemId); // 恢复之前的选择
                    return false;
                }
                break;
                
            default:
                Log.w(TAG, "未知的导航选项: " + itemId);
                return false;
        }
        
        // 如果需要登录
        if (needsLogin) {
            // 为了避免在lambda中引用非final变量，创建一个final副本
            final Fragment finalFragment = targetFragment;
            // 使用对话框检查登录状态
            pendingLoginCallback = isLoggedIn -> {
                if (isLoggedIn) {
                    // 已登录，加载目标Fragment
                    loadFragment(finalFragment);
                    lastSelectedItemId = itemId;
                } else {
                    // 未登录或者用户取消，恢复到之前的选择
                    bottomNavigationView.setSelectedItemId(lastSelectedItemId);
                }
            };
            
            LoginCheckUtil.checkLoginWithDialog(this, "查看个人信息需要登录，是否立即登录？", pendingLoginCallback);
            return true;
        } else if (targetFragment != null) {
            // 不需要登录或已登录，直接加载目标Fragment
            loadFragment(targetFragment);
            lastSelectedItemId = itemId;
            return true;
        }
        
        return false;
    }
    
    /**
     * 加载Fragment
     * @param fragment 要加载的Fragment
     */
    private void loadFragment(Fragment fragment) {
        if (fragment == null || isFinishing()) {
            return;
        }
        
        try {
            Log.d(TAG, "开始替换Fragment: " + fragment.getClass().getSimpleName());
            getSupportFragmentManager().beginTransaction()
                    .replace(R.id.fragment_container, fragment)
                    .commitAllowingStateLoss();
            Log.d(TAG, "Fragment替换事务已提交");
        } catch (Exception e) {
            Log.e(TAG, "替换Fragment失败: " + e.getMessage(), e);
        }
    }

    /**
     * 刷新所有Fragment的数据
     * 在用户登录成功后调用，确保显示最新的用户数据
     */
    private void refreshAllFragmentsData() {
        Log.d(TAG, "开始刷新所有Fragment数据");

        // 获取当前显示的Fragment
        Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.fragment_container);

        if (currentFragment instanceof WardrobeFragment) {
            Log.d(TAG, "刷新WardrobeFragment数据");
            ((WardrobeFragment) currentFragment).refreshDataAfterLogin();
        } else if (currentFragment instanceof MatchFragment) {
            Log.d(TAG, "刷新MatchFragment数据");
            ((MatchFragment) currentFragment).refreshDataAfterLogin();
        }

        // 如果当前不是衣柜或搭配页面，但用户可能会切换到这些页面
        // 我们可以设置一个标记，让这些Fragment在下次显示时自动刷新
        setNeedRefreshFlag();
    }

    /**
     * 刷新所有Fragment的分类数据
     * 当分类发生变化时调用，确保所有Fragment显示最新的分类
     */
    public void refreshCategoriesInAllFragments() {
        Log.d(TAG, "开始刷新所有Fragment的分类数据");

        // 获取所有已创建的Fragment
        List<Fragment> fragments = getSupportFragmentManager().getFragments();

        for (Fragment fragment : fragments) {
            if (fragment instanceof WardrobeFragment) {
                Log.d(TAG, "刷新WardrobeFragment分类数据");
                ((WardrobeFragment) fragment).refreshCategories();
            } else if (fragment instanceof MatchFragment) {
                Log.d(TAG, "刷新MatchFragment分类数据");
                ((MatchFragment) fragment).refreshCategories();
            }
        }
    }

    /**
     * 设置需要刷新的标记
     */
    private void setNeedRefreshFlag() {
        // 可以使用SharedPreferences来标记需要刷新
        getSharedPreferences("app_state", MODE_PRIVATE)
                .edit()
                .putBoolean("need_refresh_after_login", true)
                .apply();
    }

    /**
     * 检查应用更新，在后台线程执行，不影响UI加载
     */
    private void checkForUpdates() {
        // 在后台检查更新
        new Thread(() -> {
            try {
                // 先检查网络连接
                if (!NetworkUtil.isNetworkAvailable(this)) {
                    Log.w(TAG, "网络连接不可用，跳过检查更新");
                    return;
                }
                
                // 获取服务器主机地址和端口
                String host = ApiClient.BASE_HOST;
                int port = ApiClient.BASE_PORT;
                
                Log.d(TAG, "检查服务器可达性: " + host + ":" + port);
                
                // 设置超时时间，不要阻塞太久
                boolean isReachable = NetworkUtil.isHostReachable(host, port, 2000);
                
                if (isFinishing()) return; // 如果Activity已经结束，不执行后续操作
                
                if (isReachable) {
                    Log.d(TAG, "服务器可达，开始检查更新");
                    // 使用UpdateCheckUtil检查更新
                    runOnUiThread(() -> {
                        UpdateCheckUtil.checkUpdate(this);
                    });
                } else {
                    Log.w(TAG, "服务器不可达，跳过检查更新");
                    // 不显示错误提示，让用户正常使用App
                }
            } catch (Exception e) {
                Log.e(TAG, "检查服务器可达性失败: " + e.getMessage(), e);
                // 捕获异常但不影响用户体验
            }
        }).start();
    }
    
    @Override
    protected void onResume() {
        super.onResume();
        
        // 如果用户刚刚登录成功，检查登录状态并重置标记
        if (LoginCheckUtil.isJustLoggedIn()) {
            LoginCheckUtil.resetJustLoggedInFlag();
            Log.d(TAG, "检测到用户刚刚登录成功，刷新界面");

            // 显示欢迎信息
            Toast.makeText(this, "登录成功，欢迎回来", Toast.LENGTH_SHORT).show();

            // 刷新所有Fragment的数据
            refreshAllFragmentsData();

            // 根据之前选中的导航项加载对应的Fragment
            if (lastSelectedItemId == R.id.nav_profile) {
                // 加载个人页面
                loadFragment(new ProfileFragment());
                // 确保底部导航栏也选中了对应的项
                bottomNavigationView.setSelectedItemId(R.id.nav_profile);
            }
        }
        
        // 检查当前选中的导航项和实际显示的Fragment是否一致
        int selectedItemId = bottomNavigationView.getSelectedItemId();
        Log.d(TAG, "onResume: 当前选中的导航项 ID=" + selectedItemId + ", 资源名称=" + 
                (selectedItemId != 0 ? getResources().getResourceName(selectedItemId) : "无"));
        
        // 检查Fragment是否已加载
        Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.fragment_container);
        if (currentFragment == null) {
            Log.d(TAG, "onResume: 当前没有加载任何Fragment，加载默认Fragment");
            bottomNavigationView.setSelectedItemId(R.id.nav_wardrobe);
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        
        Log.d(TAG, "onActivityResult: requestCode=" + requestCode + ", resultCode=" + resultCode);
        
        // 处理登录请求的结果
        if (requestCode == LoginCheckUtil.LOGIN_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {
                // 用户成功登录
                Log.d(TAG, "登录成功，刷新页面");
                
                // 如果有挂起的登录回调，执行它
                if (pendingLoginCallback != null) {
                    Log.d(TAG, "执行挂起的登录回调");
                    pendingLoginCallback.onResult(true);
                    pendingLoginCallback = null; // 清除挂起的回调
                } else {
                    // 没有挂起的回调，获取当前选中的导航项，并重新加载相应的Fragment
                    int selectedItemId = bottomNavigationView.getSelectedItemId();
                    handleNavigationItemClick(selectedItemId);
                }
                
                // 显示欢迎消息
                Toast.makeText(this, "登录成功，欢迎回来", Toast.LENGTH_SHORT).show();
            } else {
                // 用户取消登录或登录失败
                Log.d(TAG, "登录取消或失败");
                
                // 如果有挂起的登录回调，执行它，通知登录失败
                if (pendingLoginCallback != null) {
                    Log.d(TAG, "执行挂起的登录回调（失败）");
                    pendingLoginCallback.onResult(false);
                    pendingLoginCallback = null; // 清除挂起的回调
                } else {
                    // 没有挂起的回调，恢复到之前的选择
                    bottomNavigationView.setSelectedItemId(lastSelectedItemId);
                }
            }
        }
    }
    
    /**
     * 处理导航项点击事件
     * @param itemId 导航项ID
     */
    private void handleNavigationItemClick(int itemId) {
        Log.d(TAG, "处理导航项点击: itemId=" + itemId);
        
        // 获取资源ID的名称
        String resourceName = "";
        try {
            resourceName = getResources().getResourceName(itemId);
            Log.d(TAG, "资源名称: " + resourceName);
        } catch (Exception e) {
            Log.e(TAG, "获取资源名称失败: " + e.getMessage());
        }
        
        // 根据itemId创建对应的Fragment
        Fragment targetFragment = null;
        
        switch (itemId) {
            case R.id.nav_wardrobe:
                Log.d(TAG, "创建衣柜页面Fragment");
                targetFragment = new WardrobeFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_match:
                Log.d(TAG, "创建搭配页面Fragment");
                targetFragment = new MatchFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_profile:
                Log.d(TAG, "创建个人页面Fragment");
                targetFragment = new ProfileFragment();
                lastSelectedItemId = itemId;
                break;
                
            case R.id.nav_tools:
                Log.d(TAG, "创建工具页面Fragment");
                targetFragment = new ToolsFragment();
                lastSelectedItemId = itemId;
                break;
                
            default:
                Log.w(TAG, "未知的导航项: " + itemId);
                return;
        }
        
        if (targetFragment != null) {
            loadFragment(targetFragment);
        }
    }
}